package znet

import (
	"fmt"
	"net"
	"zinx/Zinx/utils"
	"zinx/Zinx/ziface"
)

// IServer接口实现, 定义一个Server服务器模块
type Server struct {
	Name          string                // 服务器名称
	IPVersion     string                // 服务器绑定的ip版本
	IP            string                // 服务器监听的IP
	Port          int                   // 服务器监听的端口
	RouterHandler ziface.IRouterHandler // 服务器路由管理
	ConnManager   ziface.IConnManager   // 服务器连接管理
	// Hook
	OnConnStart func(conn ziface.IConnection) // 启动连接后的Hook
	OnConnStop  func(conn ziface.IConnection) // 停止连接前的Hook
}

// 初始化服务器
func NewServer() ziface.IServer {
	s := &Server{
		Name:          utils.Global.Name,
		IPVersion:     "tcp4",
		IP:            utils.Global.Host,
		Port:          utils.Global.TcpPort,
		RouterHandler: NewRouterHandler(),
		ConnManager:   NewConnManager(),
	}
	return s
}

// 启动服务器
func (s *Server) Start() {
	fmt.Printf("[Zinx]\nVersion: %s\nMaxConn: %d\nMaxPackageSize: %d\n", utils.Global.Version, utils.Global.MaxConn, utils.Global.MaxPackageSize)
	fmt.Printf("[Zinx]\nServer Name:%s\nListenner IP:%s:%d\n", utils.Global.Name, utils.Global.Host, utils.Global.TcpPort)
	go func() {
		// 开启工作池
		s.RouterHandler.StartWorkerPool()
		// 解析TCPAddr
		addr, err := net.ResolveTCPAddr(s.IPVersion, fmt.Sprintf("%s:%d", s.IP, s.Port))
		if err != nil {
			fmt.Println("[ResolveTCPAddr]err:", err)
			return
		}
		// 监听TCPAddr
		listenner, err := net.ListenTCP(s.IPVersion, addr)
		if err != nil {
			fmt.Println("[ListenTCP]err:", err)
			return
		}
		fmt.Println("[start] Server ", s.Name, "Listenning...")
		// 当前连接的ID
		var cid uint32 = 0
		// 阻塞等待客户端连接，并处理业务(读写)
		for {
			// 接收客户端连接
			conn, err := listenner.AcceptTCP()
			if err != nil {
				fmt.Println("[AcceptTCP]err:", err)
				continue
			}
			// 判断是否超过最大连接数
			if s.ConnManager.Len() >= utils.Global.MaxConn {
				conn.Close()
				fmt.Println("[Connection]warning: Exceeding of MaxConn")
				continue
			}
			// 调用Connection模块, 建立连接
			connection := NewConnection(s, conn, cid, s.RouterHandler)
			cid++
			go connection.Start()
		}
	}()
}

// 停止服务器
func (s *Server) Stop() {
	fmt.Println("[Server]Stop, server name: ", s.Name)
	// 回收连接资源
	s.ConnManager.ClearConn()
}

// 运行服务器
func (s *Server) Server() {
	// 启动服务器
	s.Start()
	// TODO 启动后扩展
	// 阻塞，防止服务器结束运行
	select {}
}

// 添加路由
func (s *Server) AddRouter(id uint32, router ziface.IRouter) {
	s.RouterHandler.AddRouter(id, router)
}

// 返回连接管理模块
func (s *Server) GetConnManager() ziface.IConnManager {
	return s.ConnManager
}

// 注册启动连接后的Hook
func (s *Server) SetOnConnStart(hookFunc func(conn ziface.IConnection)) {
	s.OnConnStart = hookFunc
}

// 注册关闭连接前的Hook
func (s *Server) SetOnConnStop(hookFunc func(conn ziface.IConnection)) {
	s.OnConnStop = hookFunc
}

// 调用启动连接后的Hook
func (s *Server) CallOnConnStart(conn ziface.IConnection) {
	if s.OnConnStart != nil {
		fmt.Println("——>Call AfterConnStart()..")
		s.OnConnStart(conn)
	}
}

// 调用关闭连接前的Hook
func (s *Server) CallOnConnStop(conn ziface.IConnection) {
	if s.OnConnStop != nil {
		fmt.Println("——>Call BeforeConnStop()..")
		s.OnConnStop(conn)
	}
}
